TypeScript Node.js: پیاده سازی ایمنی نوع سمت سرور

در چشم انداز همیشه در حال تحول توسعه وب، ساخت برنامه های سمت سرور قوی و قابل نگهداری بسیار مهم است. در حالی که جاوا اسکریپت مدت هاست که زبان وب بوده است، ماهیت پویای آن گاهی اوقات می تواند منجر به خطاهای زمان اجرا و مشکلاتی در مقیاس بندی پروژه های بزرگتر شود. TypeScript، یک فوق مجموعه از جاوا اسکریپت که تایپ استاتیک را اضافه می کند، یک راه حل قدرتمند برای این چالش ها ارائه می دهد. ترکیب TypeScript با Node.js یک محیط قانع کننده برای ساخت سیستم های بک اند ایمن از نوع، مقیاس پذیر و قابل نگهداری فراهم می کند.

چرا TypeScript برای توسعه سمت سرور Node.js؟

TypeScript مزایای زیادی را برای توسعه Node.js به ارمغان می آورد و بسیاری از محدودیت های ذاتی در تایپ پویای جاوا اسکریپت را برطرف می کند.

• ایمنی نوع پیشرفته: TypeScript بررسی نوع سختگیرانه را در زمان کامپایل اعمال می کند و خطاهای احتمالی را قبل از رسیدن به تولید تشخیص می دهد. این امر خطر استثنائات زمان اجرا را کاهش می دهد و ثبات کلی برنامه شما را بهبود می بخشد. سناریویی را تصور کنید که API شما یک شناسه کاربری را به عنوان یک عدد انتظار دارد اما یک رشته دریافت می کند. TypeScript این خطا را در طول توسعه علامت گذاری می کند و از یک خرابی احتمالی در تولید جلوگیری می کند.
• بهبود قابلیت نگهداری کد: حاشیه نویسی نوع، درک و بازسازی کد را آسان تر می کند. هنگام کار در یک تیم، تعاریف نوع واضح به توسعه دهندگان کمک می کند تا به سرعت هدف و رفتار مورد انتظار بخش های مختلف کد را درک کنند. این امر به ویژه برای پروژه های بلند مدت با الزامات در حال تحول بسیار مهم است.
• پشتیبانی پیشرفته IDE: تایپ استاتیک TypeScript به IDEها (محیط های توسعه یکپارچه) امکان می دهد تا تکمیل خودکار، پیمایش کد و ابزارهای بازسازی بهتری ارائه دهند. این امر به طور قابل توجهی بهره وری توسعه دهندگان را بهبود می بخشد و احتمال خطاها را کاهش می دهد. به عنوان مثال، ادغام TypeScript در VS Code پیشنهادات هوشمندانه و برجسته کردن خطا را ارائه می دهد و توسعه را سریع تر و کارآمدتر می کند.
• تشخیص زودهنگام خطا: با شناسایی خطاهای مربوط به نوع در طول کامپایل، TypeScript به شما امکان می دهد مشکلات را زودتر در چرخه توسعه برطرف کنید، در زمان صرفه جویی کنید و تلاش های اشکال زدایی را کاهش دهید. این رویکرد فعال از انتشار خطاها در سراسر برنامه و تأثیرگذاری بر کاربران جلوگیری می کند.
• پذیرش تدریجی: TypeScript یک فوق مجموعه از جاوا اسکریپت است، به این معنی که کد جاوا اسکریپت موجود را می توان به تدریج به TypeScript منتقل کرد. این به شما امکان می دهد ایمنی نوع را به صورت افزایشی معرفی کنید، بدون اینکه نیاز به بازنویسی کامل کد خود داشته باشید.

راه اندازی یک پروژه TypeScript Node.js

برای شروع کار با TypeScript و Node.js، باید Node.js و npm (مدیریت بسته Node) را نصب کنید. پس از نصب آنها، می توانید این مراحل را برای راه اندازی یک پروژه جدید دنبال کنید:

1. ایجاد یک فهرست پروژه: یک فهرست جدید برای پروژه خود ایجاد کنید و در ترمینال خود به آن بروید.
2. مقداردهی اولیه یک پروژه Node.js: برای ایجاد یک فایل package.json، دستور npm init -y را اجرا کنید.
3. نصب TypeScript: برای نصب TypeScript و تعاریف نوع Node.js، دستور npm install --save-dev typescript @types/node را اجرا کنید. بسته @types/node تعاریف نوع را برای ماژول های داخلی Node.js ارائه می دهد و به TypeScript اجازه می دهد کد Node.js شما را درک و تأیید کند.
4. ایجاد یک فایل پیکربندی TypeScript: برای ایجاد یک فایل tsconfig.json، دستور npx tsc --init را اجرا کنید. این فایل کامپایلر TypeScript را پیکربندی می کند و گزینه های کامپایل را مشخص می کند.
5. پیکربندی tsconfig.json: فایل tsconfig.json را باز کنید و آن را مطابق با نیازهای پروژه خود پیکربندی کنید. برخی از گزینه های رایج عبارتند از:
• target: نسخه هدف ECMAScript را مشخص می کند (به عنوان مثال، "es2020", "esnext").
• module: سیستم ماژول مورد استفاده را مشخص می کند (به عنوان مثال، "commonjs", "esnext").
• outDir: فهرست خروجی برای فایل های جاوا اسکریپت کامپایل شده را مشخص می کند.
• rootDir: فهرست ریشه برای فایل های منبع TypeScript را مشخص می کند.
• sourceMap: تولید نقشه منبع را برای اشکال زدایی آسان تر فعال می کند.
• strict: بررسی نوع سختگیرانه را فعال می کند.
• esModuleInterop: قابلیت همکاری بین ماژول های CommonJS و ES را فعال می کند.

یک فایل نمونه tsconfig.json ممکن است به این شکل باشد:

{
  "compilerOptions": {
    "target": "es2020",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": [
    "src/**/*"
  ]
}

این پیکربندی به کامپایلر TypeScript می گوید که تمام فایل های .ts را در فهرست src کامپایل کند، فایل های جاوا اسکریپت کامپایل شده را در فهرست dist خروجی دهد و نقشه های منبع را برای اشکال زدایی تولید کند.

حاشیه نویسی ها و رابط های نوع اساسی

TypeScript حاشیه نویسی های نوع را معرفی می کند که به شما امکان می دهد انواع متغیرها، پارامترهای تابع و مقادیر برگشتی را به صراحت مشخص کنید. این به کامپایلر TypeScript امکان می دهد تا بررسی نوع را انجام دهد و خطاها را زود تشخیص دهد.

انواع اساسی

TypeScript از انواع اساسی زیر پشتیبانی می کند:

• string: مقادیر متنی را نشان می دهد.
• number: مقادیر عددی را نشان می دهد.
• boolean: مقادیر بولی (true یا false) را نشان می دهد.
• null: فقدان عمدی یک مقدار را نشان می دهد.
• undefined: متغیری را نشان می دهد که به آن مقداری اختصاص داده نشده است.
• symbol: یک مقدار منحصر به فرد و تغییرناپذیر را نشان می دهد.
• bigint: اعداد صحیح با دقت دلخواه را نشان می دهد.
• any: یک مقدار از هر نوع را نشان می دهد (به ندرت استفاده کنید).
• unknown: مقداری را نشان می دهد که نوع آن ناشناخته است (ایمن تر از any).
• void: عدم وجود مقدار برگشتی از یک تابع را نشان می دهد.
• never: مقداری را نشان می دهد که هرگز رخ نمی دهد (به عنوان مثال، تابعی که همیشه یک خطا پرتاب می کند).
• array: یک مجموعه مرتب از مقادیر از یک نوع را نشان می دهد (به عنوان مثال، string[], number[]).
• tuple: یک مجموعه مرتب از مقادیر با انواع خاص را نشان می دهد (به عنوان مثال، [string, number]).
• enum: مجموعه ای از ثابت های نامگذاری شده را نشان می دهد.
• object: یک نوع غیر بدوی را نشان می دهد.

در اینجا چند نمونه از حاشیه نویسی های نوع آورده شده است:

let name: string = "John Doe";
let age: number = 30;
let isStudent: boolean = false;

function greet(name: string): string {
  return `Hello, ${name}!`;
}

let numbers: number[] = [1, 2, 3, 4, 5];

let person: { name: string; age: number } = {
  name: "Jane Doe",
  age: 25,
};

رابط ها

رابط ها ساختار یک شی را تعریف می کنند. آنها ویژگی ها و روش هایی را مشخص می کنند که یک شی باید داشته باشد. رابط ها یک راه قدرتمند برای اعمال ایمنی نوع و بهبود قابلیت نگهداری کد هستند.

در اینجا یک مثال از یک رابط آورده شده است:

interface User {
  id: number;
  name: string;
  email: string;
  isActive: boolean;
}

function getUser(id: number): User {
  // ... واکشی داده های کاربر از پایگاه داده
  return {
    id: 1,
    name: "John Doe",
    email: "john.doe@example.com",
    isActive: true,
  };
}

let user: User = getUser(1);

console.log(user.name); // John Doe

در این مثال، رابط User ساختار یک شی کاربر را تعریف می کند. تابع getUser یک شی را برمی گرداند که با رابط User مطابقت دارد. اگر تابع یک شی را برگرداند که با رابط مطابقت نداشته باشد، کامپایلر TypeScript یک خطا پرتاب می کند.

نام مستعار نوع

نام مستعار نوع، نام جدیدی برای یک نوع ایجاد می کند. آنها نوع جدیدی ایجاد نمی کنند - آنها فقط به یک نوع موجود یک نام توصیفی تر یا راحت تر می دهند.

type StringOrNumber = string | number;

let value: StringOrNumber = "hello";
value = 123;

//نام مستعار نوع برای یک شی پیچیده
type Point = {
 x: number;
 y: number;
};

const myPoint: Point = { x: 10, y: 20 };

ساخت یک API ساده با TypeScript و Node.js

بیایید یک API REST ساده با استفاده از TypeScript، Node.js و Express.js بسازیم.

1. نصب Express.js و تعاریف نوع آن: دستور npm install express @types/express را اجرا کنید
2. یک فایل به نام src/index.ts با کد زیر ایجاد کنید:

import express, { Request, Response } from 'express';

const app = express();
const port = process.env.PORT || 3000;

interface Product {
  id: number;
  name: string;
  price: number;
}

const products: Product[] = [
  { id: 1, name: 'Laptop', price: 1200 },
  { id: 2, name: 'Keyboard', price: 75 },
  { id: 3, name: 'Mouse', price: 25 },
];

app.get('/products', (req: Request, res: Response) => {
  res.json(products);
});

app.get('/products/:id', (req: Request, res: Response) => {
  const productId = parseInt(req.params.id);
  const product = products.find(p => p.id === productId);

  if (product) {
    res.json(product);
  } else {
    res.status(404).json({ message: 'Product not found' });
  }
});

app.listen(port, () => {
  console.log(`Server is running on port ${port}`);
});

این کد یک API ساده Express.js با دو نقطه پایانی ایجاد می کند:

• /products: لیستی از محصولات را برمی گرداند.
• /products/:id: یک محصول خاص را بر اساس شناسه برمی گرداند.

رابط Product ساختار یک شی محصول را تعریف می کند. آرایه products حاوی لیستی از اشیاء محصول است که با رابط Product مطابقت دارند.

برای اجرای API، باید کد TypeScript را کامپایل کنید و سرور Node.js را راه اندازی کنید:

1. کامپایل کد TypeScript: دستور npm run tsc را اجرا کنید (ممکن است لازم باشد این اسکریپت را در package.json به عنوان "tsc": "tsc" تعریف کنید).
2. راه اندازی سرور Node.js: دستور node dist/index.js را اجرا کنید.

سپس می توانید به نقاط پایانی API در مرورگر خود یا با ابزاری مانند curl دسترسی پیدا کنید:

curl http://localhost:3000/products
curl http://localhost:3000/products/1

تکنیک های پیشرفته TypeScript برای توسعه سمت سرور

TypeScript چندین ویژگی پیشرفته را ارائه می دهد که می تواند ایمنی نوع و کیفیت کد را در توسعه سمت سرور افزایش دهد.

عمومیات

عمومیات به شما امکان می دهد کدی بنویسید که می تواند با انواع مختلف بدون قربانی کردن ایمنی نوع کار کند. آنها راهی برای پارامتری کردن انواع ارائه می دهند و کد شما را قابل استفاده مجدد و انعطاف پذیرتر می کنند.

در اینجا یک مثال از یک تابع عمومی آورده شده است:

function identity<T>(arg: T): T {
  return arg;
}

let myString: string = identity<string>("hello");
let myNumber: number = identity<number>(123);

در این مثال، تابع identity آرگومانی از نوع T می گیرد و مقداری از همان نوع را برمی گرداند. نحو <T> نشان می دهد که T یک پارامتر نوع است. هنگامی که تابع را فراخوانی می کنید، می توانید نوع T را به صراحت مشخص کنید (به عنوان مثال، identity<string>) یا به TypeScript اجازه دهید آن را از آرگومان استنباط کند (به عنوان مثال، identity("hello")).

اتحادیه های متمایز

اتحادیه های متمایز، همچنین به عنوان اتحادیه های برچسب گذاری شده شناخته می شوند، یک راه قدرتمند برای نشان دادن مقادیری هستند که می توانند یکی از چندین نوع مختلف باشند. آنها اغلب برای مدل سازی ماشین های حالت یا نشان دادن انواع مختلف خطاها استفاده می شوند.

در اینجا یک مثال از یک اتحادیه متمایز آورده شده است:

type Success = {
  status: 'success';
  data: any;
};

type Error = {
  status: 'error';
  message: string;
};

type Result = Success | Error;

function handleResult(result: Result) {
  if (result.status === 'success') {
    console.log('Success:', result.data);
  } else {
    console.error('Error:', result.message);
  }
}

const successResult: Success = { status: 'success', data: { name: 'John Doe' } };
const errorResult: Error = { status: 'error', message: 'Something went wrong' };

handleResult(successResult);
handleResult(errorResult);

در این مثال، نوع Result یک اتحادیه متمایز از انواع Success و Error است. ویژگی status متمایز کننده است که نشان می دهد مقدار از چه نوعی است. تابع handleResult از متمایز کننده برای تعیین نحوه مدیریت مقدار استفاده می کند.

انواع ابزار

TypeScript چندین نوع ابزار داخلی را ارائه می دهد که می تواند به شما در دستکاری انواع و ایجاد کد مختصرتر و رسا تر کمک کند. برخی از انواع ابزار پرکاربرد عبارتند از:

• Partial<T>: تمام ویژگی های T را اختیاری می کند.
• Required<T>: تمام ویژگی های T را مورد نیاز می کند.
• Readonly<T>: تمام ویژگی های T را فقط خواندنی می کند.
• Pick<T, K>: یک نوع جدید فقط با ویژگی های T که کلیدهای آنها در K هستند، ایجاد می کند.
• Omit<T, K>: یک نوع جدید با تمام ویژگی های T به جز آنهایی که کلیدهای آنها در K هستند، ایجاد می کند.
• Record<K, T>: یک نوع جدید با کلیدهای نوع K و مقادیر نوع T ایجاد می کند.
• Exclude<T, U>: از T تمام انواع قابل تخصیص به U را حذف می کند.
• Extract<T, U>: از T تمام انواع قابل تخصیص به U را استخراج می کند.
• NonNullable<T>: null و undefined را از T حذف می کند.
• Parameters<T>: پارامترهای یک نوع تابع T را در یک تاپل به دست می آورد.
• ReturnType<T>: نوع برگشتی یک نوع تابع T را به دست می آورد.
• InstanceType<T>: نوع نمونه یک نوع تابع سازنده T را به دست می آورد.

در اینجا چند نمونه از نحوه استفاده از انواع ابزار آورده شده است:

interface User {
  id: number;
  name: string;
  email: string;
}

// اختیاری کردن تمام ویژگی های کاربر
type PartialUser = Partial<User>;

// ایجاد یک نوع فقط با ویژگی های نام و ایمیل کاربر
type UserInfo = Pick<User, 'name' | 'email'>;

// ایجاد یک نوع با تمام ویژگی های کاربر به جز شناسه
type UserWithoutId = Omit<User, 'id'>;

تست برنامه های TypeScript Node.js

تست یک بخش اساسی از ساخت برنامه های سمت سرور قوی و قابل اعتماد است. هنگام استفاده از TypeScript، می توانید از سیستم نوع برای نوشتن تست های مؤثرتر و قابل نگهداری تر استفاده کنید.

چارچوب های تست محبوب برای Node.js شامل Jest و Mocha هستند. این چارچوب ها ویژگی های مختلفی را برای نوشتن تست های واحد، تست های یکپارچه سازی و تست های سرتاسری ارائه می دهند.

در اینجا یک مثال از یک تست واحد با استفاده از Jest آورده شده است:

// src/utils.ts
export function add(a: number, b: number): number {
  return a + b;
}

// test/utils.test.ts
import { add } from '../src/utils';

describe('add', () => {
  it('should return the sum of two numbers', () => {
    expect(add(1, 2)).toBe(3);
  });

  it('should handle negative numbers', () => {
    expect(add(-1, 2)).toBe(1);
  });
});

در این مثال، تابع add با استفاده از Jest تست می شود. بلوک describe تست های مرتبط را با هم گروه بندی می کند. بلوک های it موارد تست فردی را تعریف می کنند. از تابع expect برای ادعای رفتار کد استفاده می شود.

هنگام نوشتن تست برای کد TypeScript، مهم است که اطمینان حاصل کنید که تست های شما تمام سناریوهای نوع ممکن را پوشش می دهند. این شامل آزمایش با انواع مختلف ورودی ها، آزمایش با مقادیر null و undefined و آزمایش با داده های نامعتبر است.

بهترین شیوه ها برای توسعه TypeScript Node.js

برای اطمینان از اینکه پروژه های TypeScript Node.js شما به خوبی ساختار یافته، قابل نگهداری و مقیاس پذیر هستند، مهم است که برخی از بهترین شیوه ها را دنبال کنید:

• استفاده از حالت سختگیرانه: حالت سختگیرانه را در فایل tsconfig.json خود فعال کنید تا بررسی نوع سختگیرانه تری را اعمال کنید و خطاهای احتمالی را زود تشخیص دهید.
• تعریف رابط ها و انواع واضح: از رابط ها و انواع برای تعریف ساختار داده های خود استفاده کنید و از ایمنی نوع در سراسر برنامه خود اطمینان حاصل کنید.
• استفاده از عمومیات: از عمومیات برای نوشتن کد قابل استفاده مجدد استفاده کنید که می تواند با انواع مختلف بدون قربانی کردن ایمنی نوع کار کند.
• استفاده از اتحادیه های متمایز: از اتحادیه های متمایز برای نشان دادن مقادیری استفاده کنید که می توانند یکی از چندین نوع مختلف باشند.
• نوشتن تست های جامع: تست های واحد، تست های یکپارچه سازی و تست های سرتاسری را برای اطمینان از اینکه کد شما به درستی کار می کند و برنامه شما پایدار است، بنویسید.
• دنبال کردن یک سبک کدنویسی ثابت: از یک فرمت کننده کد مانند Prettier و یک لینتر مانند ESLint برای اعمال یک سبک کدنویسی ثابت و تشخیص خطاهای احتمالی استفاده کنید. این امر به ویژه هنگام کار با یک تیم برای حفظ یک کد منبع ثابت مهم است. گزینه های پیکربندی بسیاری برای ESLint و Prettier وجود دارد که می تواند در سراسر تیم به اشتراک گذاشته شود.
• استفاده از تزریق وابستگی: تزریق وابستگی یک الگوی طراحی است که به شما امکان می دهد کد خود را از هم جدا کنید و آن را قابل آزمایش تر کنید. ابزارهایی مانند InversifyJS می توانند به شما در پیاده سازی تزریق وابستگی در پروژه های TypeScript Node.js کمک کنند.
• پیاده سازی مدیریت خطای مناسب: مدیریت خطای قوی را برای تشخیص و مدیریت استثناها به طور ظریف پیاده سازی کنید. از بلوک های try-catch و ثبت خطا برای جلوگیری از خرابی برنامه خود و ارائه اطلاعات اشکال زدایی مفید استفاده کنید.
• استفاده از یک بسته کننده ماژول: از یک بسته کننده ماژول مانند Webpack یا Parcel برای بسته بندی کد خود و بهینه سازی آن برای تولید استفاده کنید. در حالی که اغلب با توسعه فرانت اند مرتبط است، بسته کننده های ماژول می توانند برای پروژه های Node.js نیز مفید باشند، به ویژه هنگام کار با ماژول های ES.
• در نظر گرفتن استفاده از یک چارچوب: چارچوب هایی مانند NestJS یا AdonisJS را بررسی کنید که یک ساختار و قرارداد برای ساخت برنامه های Node.js مقیاس پذیر و قابل نگهداری با TypeScript ارائه می دهند. این چارچوب ها اغلب شامل ویژگی هایی مانند تزریق وابستگی، مسیریابی و پشتیبانی از میان افزار هستند.

ملاحظات استقرار

استقرار یک برنامه TypeScript Node.js مشابه استقرار یک برنامه استاندارد Node.js است. با این حال، چند ملاحظه اضافی وجود دارد:

• کامپایل: قبل از استقرار آن، باید کد TypeScript خود را به جاوا اسکریپت کامپایل کنید. این کار می تواند به عنوان بخشی از فرآیند ساخت شما انجام شود.
• نقشه های منبع: در نظر بگیرید که نقشه های منبع را در بسته استقرار خود قرار دهید تا اشکال زدایی در تولید آسان تر شود.
• متغیرهای محیطی: از متغیرهای محیطی برای پیکربندی برنامه خود برای محیط های مختلف (به عنوان مثال، توسعه، مرحله بندی، تولید) استفاده کنید. این یک عمل استاندارد است، اما هنگام برخورد با کد کامپایل شده اهمیت بیشتری پیدا می کند.

پلتفرم های استقرار محبوب برای Node.js عبارتند از:

• AWS (Amazon Web Services): انواع خدمات را برای استقرار برنامه های Node.js، از جمله EC2، Elastic Beanstalk و Lambda ارائه می دهد.
• Google Cloud Platform (GCP): خدمات مشابهی را به AWS ارائه می دهد، از جمله Compute Engine، App Engine و Cloud Functions.
• Microsoft Azure: خدماتی مانند ماشین های مجازی، App Service و Azure Functions را برای استقرار برنامه های Node.js ارائه می دهد.
• Heroku: یک پلتفرم به عنوان یک سرویس (PaaS) است که استقرار و مدیریت برنامه های Node.js را ساده می کند.
• DigitalOcean: سرورهای خصوصی مجازی (VPS) را ارائه می دهد که می توانید از آنها برای استقرار برنامه های Node.js استفاده کنید.
• Docker: یک فناوری کانتینری سازی است که به شما امکان می دهد برنامه و وابستگی های خود را در یک کانتینر واحد بسته بندی کنید. این کار استقرار برنامه شما را در هر محیطی که از Docker پشتیبانی می کند آسان می کند.

نتیجه گیری

TypeScript یک بهبود قابل توجه نسبت به جاوا اسکریپت سنتی برای ساخت برنامه های سمت سرور قوی و مقیاس پذیر با Node.js ارائه می دهد. با استفاده از ایمنی نوع، پشتیبانی پیشرفته IDE و ویژگی های پیشرفته زبان، می توانید سیستم های بک اند قابل نگهداری، قابل اعتماد و کارآمدتری ایجاد کنید. در حالی که در پذیرش TypeScript یک منحنی یادگیری وجود دارد، مزایای بلندمدت از نظر کیفیت کد و بهره وری توسعه دهندگان، آن را به یک سرمایه گذاری ارزشمند تبدیل می کند. با ادامه افزایش تقاضا برای برنامه های کاربردی ساختار یافته و قابل نگهداری، TypeScript آماده است تا به ابزاری مهم تر برای توسعه دهندگان سمت سرور در سراسر جهان تبدیل شود.